/*
** Lua binding: MyGame
** Generated automatically by tolua++-1.0.92 on 07/24/12 12:23:08.
*/

#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "tolua++.h"

/* Exported function */
TOLUA_API int  tolua_MyGame_open (lua_State* tolua_S);

#include "LuaCocos2d.h"
#include "tolua_fix.h"
#include "CC2DFileCache.h"
#include "CC2DNodeFile.h"
#include "CCATFileCache.h"
#include "XmlParser.h"
#include "ActionExt.h"
#include "SpriteExt.h"
#include "cocos2d.h"
#include "Misc.h"
#include <string>
#include "NetManager.h"
#include "PlayerMsgProcess.h"
#include "UIWidget.h"
#include "UIButton.h"

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_VDeleteNode (lua_State* tolua_S)
{
 VDeleteNode* self = (VDeleteNode*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_std__vector_int_ (lua_State* tolua_S)
{
 std::vector<int>* self = (std::vector<int>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cocos2d__ccColor4B (lua_State* tolua_S)
{
 cocos2d::ccColor4B* self = (cocos2d::ccColor4B*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_SpriteExt (lua_State* tolua_S)
{
 SpriteExt* self = (SpriteExt*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DParticleSystem (lua_State* tolua_S)
{
 CC2DParticleSystem* self = (CC2DParticleSystem*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_VSetGridNull (lua_State* tolua_S)
{
 VSetGridNull* self = (VSetGridNull*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DLayer (lua_State* tolua_S)
{
 CC2DLayer* self = (CC2DLayer*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DSpriteExt (lua_State* tolua_S)
{
 CC2DSpriteExt* self = (CC2DSpriteExt*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DFileCache (lua_State* tolua_S)
{
 CC2DFileCache* self = (CC2DFileCache*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cocos2d__CCSize (lua_State* tolua_S)
{
 cocos2d::CCSize* self = (cocos2d::CCSize*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_std__vector_std__string_ (lua_State* tolua_S)
{
 std::vector<std::string>* self = (std::vector<std::string>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_UIButton (lua_State* tolua_S)
{
 UIButton* self = (UIButton*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cocos2d__CCPoint (lua_State* tolua_S)
{
 cocos2d::CCPoint* self = (cocos2d::CCPoint*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DProgressTimer (lua_State* tolua_S)
{
 CC2DProgressTimer* self = (CC2DProgressTimer*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DNode (lua_State* tolua_S)
{
 CC2DNode* self = (CC2DNode*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_XmlParser (lua_State* tolua_S)
{
 XmlParser* self = (XmlParser*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DCircle (lua_State* tolua_S)
{
 CC2DCircle* self = (CC2DCircle*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DPolygon (lua_State* tolua_S)
{
 CC2DPolygon* self = (CC2DPolygon*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CCATFileCache (lua_State* tolua_S)
{
 CCATFileCache* self = (CCATFileCache*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DMenuItemImage (lua_State* tolua_S)
{
 CC2DMenuItemImage* self = (CC2DMenuItemImage*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_std__vector_float_ (lua_State* tolua_S)
{
 std::vector<float>* self = (std::vector<float>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_UIWidget (lua_State* tolua_S)
{
 UIWidget* self = (UIWidget*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_VCC2DLoad (lua_State* tolua_S)
{
 VCC2DLoad* self = (VCC2DLoad*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DMenu (lua_State* tolua_S)
{
 CC2DMenu* self = (CC2DMenu*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DScene (lua_State* tolua_S)
{
 CC2DScene* self = (CC2DScene*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_xmlNodePtr (lua_State* tolua_S)
{
 xmlNodePtr* self = (xmlNodePtr*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DBody (lua_State* tolua_S)
{
 CC2DBody* self = (CC2DBody*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_VNodeRunAction (lua_State* tolua_S)
{
 VNodeRunAction* self = (VNodeRunAction*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DParallaxNode (lua_State* tolua_S)
{
 CC2DParallaxNode* self = (CC2DParallaxNode*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_VSoundPlay (lua_State* tolua_S)
{
 VSoundPlay* self = (VSoundPlay*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_sgs_connection_state (lua_State* tolua_S)
{
 sgs_connection_state* self = (sgs_connection_state*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DRectangle (lua_State* tolua_S)
{
 CC2DRectangle* self = (CC2DRectangle*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DWorld (lua_State* tolua_S)
{
 CC2DWorld* self = (CC2DWorld*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cocos2d__CCRect (lua_State* tolua_S)
{
 cocos2d::CCRect* self = (cocos2d::CCRect*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CC2DSprite (lua_State* tolua_S)
{
 CC2DSprite* self = (CC2DSprite*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"VDeleteNode");
 tolua_usertype(tolua_S,"std::vector<int>");
 tolua_usertype(tolua_S,"cocos2d::ccColor4B");
 tolua_usertype(tolua_S,"SpriteExt");
 tolua_usertype(tolua_S,"CC2DParticleSystem");
 tolua_usertype(tolua_S,"CCFiniteTimeAction");
 tolua_usertype(tolua_S,"CCNode");
 tolua_usertype(tolua_S,"VSetGridNull");
 tolua_usertype(tolua_S,"CC2DLayer");
 tolua_usertype(tolua_S,"CC2DSpriteExt");
 tolua_usertype(tolua_S,"CC2DFileCache");
 tolua_usertype(tolua_S,"cocos2d::CCSize");
 tolua_usertype(tolua_S,"CCScene");
 tolua_usertype(tolua_S,"size_t");
 tolua_usertype(tolua_S,"CNetManager");
 tolua_usertype(tolua_S,"UIButton");
 tolua_usertype(tolua_S,"CCLayer");
 tolua_usertype(tolua_S,"LUA_FUNCTION");
 tolua_usertype(tolua_S,"CCObject");
 tolua_usertype(tolua_S,"UIWidget");
 tolua_usertype(tolua_S,"CCActionInstant");
 tolua_usertype(tolua_S,"CC2DProgressTimer");
 tolua_usertype(tolua_S,"CC2DNode");
 tolua_usertype(tolua_S,"CPlayerMsgProcess");
 tolua_usertype(tolua_S,"sgs_connection_state");
 tolua_usertype(tolua_S,"XmlParser");
 tolua_usertype(tolua_S,"CC2DCircle");
 tolua_usertype(tolua_S,"Misc");
 tolua_usertype(tolua_S,"CCRect");
 tolua_usertype(tolua_S,"CC2DPolygon");
 tolua_usertype(tolua_S,"std::vector<float>");
 tolua_usertype(tolua_S,"CCATFileCache");
 tolua_usertype(tolua_S,"CC2DFixture");
 tolua_usertype(tolua_S,"CC2DBody");
 tolua_usertype(tolua_S,"VNodeRunAction");
 tolua_usertype(tolua_S,"CCAction");
 tolua_usertype(tolua_S,"b2World");
 tolua_usertype(tolua_S,"CC2DMenu");
 tolua_usertype(tolua_S,"CC2DMenuItemImage");
 tolua_usertype(tolua_S,"VSoundPlay");
 tolua_usertype(tolua_S,"VCC2DLoad");
 tolua_usertype(tolua_S,"std::vector<std::string>");
 tolua_usertype(tolua_S,"CC2DScene");
 tolua_usertype(tolua_S,"xmlNodePtr");
 tolua_usertype(tolua_S,"cocos2d::CCPoint");
 tolua_usertype(tolua_S,"cocos2d::CCRect");
 tolua_usertype(tolua_S,"CC2DSprite");
 tolua_usertype(tolua_S,"CCZone");
 tolua_usertype(tolua_S,"CCSprite");
 tolua_usertype(tolua_S,"CC2DRectangle");
 tolua_usertype(tolua_S,"b2Body");
 tolua_usertype(tolua_S,"CC2DParallaxNode");
 tolua_usertype(tolua_S,"CC2DWorld");
}

/* method: new of class  CC2DFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DFileCache_new00
static int tolua_MyGame_CC2DFileCache_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DFileCache* tolua_ret = (CC2DFileCache*)  Mtolua_new((CC2DFileCache)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DFileCache");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DFileCache_new00_local
static int tolua_MyGame_CC2DFileCache_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DFileCache* tolua_ret = (CC2DFileCache*)  Mtolua_new((CC2DFileCache)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DFileCache");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DFileCache_delete00
static int tolua_MyGame_CC2DFileCache_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DFileCache* self = (CC2DFileCache*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sharedCC2DFileCache of class  CC2DFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DFileCache_sharedCC2DFileCache00
static int tolua_MyGame_CC2DFileCache_sharedCC2DFileCache00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DFileCache* tolua_ret = (CC2DFileCache*)  CC2DFileCache::sharedCC2DFileCache();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DFileCache");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sharedCC2DFileCache'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addCC2DNode of class  CC2DFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DFileCache_addCC2DNode00
static int tolua_MyGame_CC2DFileCache_addCC2DNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DFileCache",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DFileCache* self = (CC2DFileCache*)  tolua_tousertype(tolua_S,1,0);
  const char* fileimage = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addCC2DNode'", NULL);
#endif
  {
   CC2DNode* tolua_ret = (CC2DNode*)  self->addCC2DNode(fileimage);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addCC2DNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DNode_new00
static int tolua_MyGame_CC2DNode_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DNode* tolua_ret = (CC2DNode*)  Mtolua_new((CC2DNode)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DNode_new00_local
static int tolua_MyGame_CC2DNode_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DNode* tolua_ret = (CC2DNode*)  Mtolua_new((CC2DNode)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DNode");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DNode_delete00
static int tolua_MyGame_CC2DNode_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DNode* self = (CC2DNode*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DNode_createCCNode00
static int tolua_MyGame_CC2DNode_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DNode",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DNode* self = (CC2DNode*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DNode_initProperties00
static int tolua_MyGame_CC2DNode_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DNode",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DNode* self = (CC2DNode*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DNode_load00
static int tolua_MyGame_CC2DNode_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DNode",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DNode* self = (CC2DNode*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DSprite */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSprite_new00
static int tolua_MyGame_CC2DSprite_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DSprite",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DSprite* tolua_ret = (CC2DSprite*)  Mtolua_new((CC2DSprite)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DSprite");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DSprite */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSprite_new00_local
static int tolua_MyGame_CC2DSprite_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DSprite",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DSprite* tolua_ret = (CC2DSprite*)  Mtolua_new((CC2DSprite)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DSprite");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DSprite */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSprite_delete00
static int tolua_MyGame_CC2DSprite_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSprite",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSprite* self = (CC2DSprite*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DSprite */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSprite_createCCNode00
static int tolua_MyGame_CC2DSprite_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSprite",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSprite* self = (CC2DSprite*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DSprite */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSprite_initProperties00
static int tolua_MyGame_CC2DSprite_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSprite",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSprite* self = (CC2DSprite*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DSprite */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSprite_load00
static int tolua_MyGame_CC2DSprite_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSprite",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSprite* self = (CC2DSprite*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DParticleSystem */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParticleSystem_new00
static int tolua_MyGame_CC2DParticleSystem_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DParticleSystem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DParticleSystem* tolua_ret = (CC2DParticleSystem*)  Mtolua_new((CC2DParticleSystem)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DParticleSystem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DParticleSystem */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParticleSystem_new00_local
static int tolua_MyGame_CC2DParticleSystem_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DParticleSystem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DParticleSystem* tolua_ret = (CC2DParticleSystem*)  Mtolua_new((CC2DParticleSystem)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DParticleSystem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DParticleSystem */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParticleSystem_delete00
static int tolua_MyGame_CC2DParticleSystem_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DParticleSystem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DParticleSystem* self = (CC2DParticleSystem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DParticleSystem */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParticleSystem_createCCNode00
static int tolua_MyGame_CC2DParticleSystem_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DParticleSystem",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DParticleSystem* self = (CC2DParticleSystem*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DParticleSystem */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParticleSystem_initProperties00
static int tolua_MyGame_CC2DParticleSystem_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DParticleSystem",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DParticleSystem* self = (CC2DParticleSystem*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DParticleSystem */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParticleSystem_load00
static int tolua_MyGame_CC2DParticleSystem_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DParticleSystem",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DParticleSystem* self = (CC2DParticleSystem*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DLayer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DLayer_new00
static int tolua_MyGame_CC2DLayer_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DLayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DLayer* tolua_ret = (CC2DLayer*)  Mtolua_new((CC2DLayer)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DLayer");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DLayer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DLayer_new00_local
static int tolua_MyGame_CC2DLayer_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DLayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DLayer* tolua_ret = (CC2DLayer*)  Mtolua_new((CC2DLayer)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DLayer");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DLayer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DLayer_delete00
static int tolua_MyGame_CC2DLayer_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DLayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DLayer* self = (CC2DLayer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DLayer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DLayer_createCCNode00
static int tolua_MyGame_CC2DLayer_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DLayer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DLayer* self = (CC2DLayer*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DLayer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DLayer_initProperties00
static int tolua_MyGame_CC2DLayer_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DLayer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DLayer* self = (CC2DLayer*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DLayer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DLayer_load00
static int tolua_MyGame_CC2DLayer_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DLayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DLayer* self = (CC2DLayer*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DProgressTimer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DProgressTimer_new00
static int tolua_MyGame_CC2DProgressTimer_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DProgressTimer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DProgressTimer* tolua_ret = (CC2DProgressTimer*)  Mtolua_new((CC2DProgressTimer)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DProgressTimer");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DProgressTimer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DProgressTimer_new00_local
static int tolua_MyGame_CC2DProgressTimer_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DProgressTimer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DProgressTimer* tolua_ret = (CC2DProgressTimer*)  Mtolua_new((CC2DProgressTimer)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DProgressTimer");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DProgressTimer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DProgressTimer_delete00
static int tolua_MyGame_CC2DProgressTimer_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DProgressTimer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DProgressTimer* self = (CC2DProgressTimer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DProgressTimer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DProgressTimer_createCCNode00
static int tolua_MyGame_CC2DProgressTimer_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DProgressTimer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DProgressTimer* self = (CC2DProgressTimer*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DProgressTimer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DProgressTimer_initProperties00
static int tolua_MyGame_CC2DProgressTimer_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DProgressTimer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DProgressTimer* self = (CC2DProgressTimer*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DProgressTimer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DProgressTimer_load00
static int tolua_MyGame_CC2DProgressTimer_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DProgressTimer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DProgressTimer* self = (CC2DProgressTimer*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DParallaxNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParallaxNode_new00
static int tolua_MyGame_CC2DParallaxNode_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DParallaxNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DParallaxNode* tolua_ret = (CC2DParallaxNode*)  Mtolua_new((CC2DParallaxNode)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DParallaxNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DParallaxNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParallaxNode_new00_local
static int tolua_MyGame_CC2DParallaxNode_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DParallaxNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DParallaxNode* tolua_ret = (CC2DParallaxNode*)  Mtolua_new((CC2DParallaxNode)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DParallaxNode");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DParallaxNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParallaxNode_delete00
static int tolua_MyGame_CC2DParallaxNode_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DParallaxNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DParallaxNode* self = (CC2DParallaxNode*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DParallaxNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParallaxNode_createCCNode00
static int tolua_MyGame_CC2DParallaxNode_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DParallaxNode",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DParallaxNode* self = (CC2DParallaxNode*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DScene */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DScene_new00
static int tolua_MyGame_CC2DScene_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DScene",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DScene* tolua_ret = (CC2DScene*)  Mtolua_new((CC2DScene)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DScene");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DScene */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DScene_new00_local
static int tolua_MyGame_CC2DScene_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DScene",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DScene* tolua_ret = (CC2DScene*)  Mtolua_new((CC2DScene)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DScene");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DScene */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DScene_delete00
static int tolua_MyGame_CC2DScene_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DScene",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DScene* self = (CC2DScene*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DScene */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DScene_createCCNode00
static int tolua_MyGame_CC2DScene_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DScene",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DScene* self = (CC2DScene*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCScene* tolua_ret = (CCScene*)  self->createCCNode(parent);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCScene");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DMenu */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenu_new00
static int tolua_MyGame_CC2DMenu_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DMenu",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DMenu* tolua_ret = (CC2DMenu*)  Mtolua_new((CC2DMenu)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DMenu");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DMenu */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenu_new00_local
static int tolua_MyGame_CC2DMenu_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DMenu",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DMenu* tolua_ret = (CC2DMenu*)  Mtolua_new((CC2DMenu)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DMenu");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DMenu */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenu_delete00
static int tolua_MyGame_CC2DMenu_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DMenu",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DMenu* self = (CC2DMenu*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DMenu */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenu_createCCNode00
static int tolua_MyGame_CC2DMenu_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DMenu",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DMenu* self = (CC2DMenu*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DMenuItemImage */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenuItemImage_new00
static int tolua_MyGame_CC2DMenuItemImage_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DMenuItemImage",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DMenuItemImage* tolua_ret = (CC2DMenuItemImage*)  Mtolua_new((CC2DMenuItemImage)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DMenuItemImage");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DMenuItemImage */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenuItemImage_new00_local
static int tolua_MyGame_CC2DMenuItemImage_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DMenuItemImage",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DMenuItemImage* tolua_ret = (CC2DMenuItemImage*)  Mtolua_new((CC2DMenuItemImage)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DMenuItemImage");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DMenuItemImage */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenuItemImage_delete00
static int tolua_MyGame_CC2DMenuItemImage_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DMenuItemImage",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DMenuItemImage* self = (CC2DMenuItemImage*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DMenuItemImage */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenuItemImage_createCCNode00
static int tolua_MyGame_CC2DMenuItemImage_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DMenuItemImage",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DMenuItemImage* self = (CC2DMenuItemImage*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DMenuItemImage */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenuItemImage_initProperties00
static int tolua_MyGame_CC2DMenuItemImage_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DMenuItemImage",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DMenuItemImage* self = (CC2DMenuItemImage*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DMenuItemImage */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenuItemImage_load00
static int tolua_MyGame_CC2DMenuItemImage_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DMenuItemImage",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DMenuItemImage* self = (CC2DMenuItemImage*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DSpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSpriteExt_new00
static int tolua_MyGame_CC2DSpriteExt_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DSpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DSpriteExt* tolua_ret = (CC2DSpriteExt*)  Mtolua_new((CC2DSpriteExt)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DSpriteExt");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DSpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSpriteExt_new00_local
static int tolua_MyGame_CC2DSpriteExt_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DSpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DSpriteExt* tolua_ret = (CC2DSpriteExt*)  Mtolua_new((CC2DSpriteExt)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DSpriteExt");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DSpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSpriteExt_delete00
static int tolua_MyGame_CC2DSpriteExt_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSpriteExt* self = (CC2DSpriteExt*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DSpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSpriteExt_createCCNode00
static int tolua_MyGame_CC2DSpriteExt_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSpriteExt",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSpriteExt* self = (CC2DSpriteExt*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DSpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSpriteExt_initProperties00
static int tolua_MyGame_CC2DSpriteExt_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSpriteExt",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSpriteExt* self = (CC2DSpriteExt*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DSpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSpriteExt_load00
static int tolua_MyGame_CC2DSpriteExt_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSpriteExt",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSpriteExt* self = (CC2DSpriteExt*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DWorld */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DWorld_new00
static int tolua_MyGame_CC2DWorld_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DWorld* tolua_ret = (CC2DWorld*)  Mtolua_new((CC2DWorld)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DWorld");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DWorld */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DWorld_new00_local
static int tolua_MyGame_CC2DWorld_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DWorld* tolua_ret = (CC2DWorld*)  Mtolua_new((CC2DWorld)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DWorld");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DWorld */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DWorld_delete00
static int tolua_MyGame_CC2DWorld_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DWorld* self = (CC2DWorld*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createWorld of class  CC2DWorld */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DWorld_createWorld00
static int tolua_MyGame_CC2DWorld_createWorld00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DWorld* self = (CC2DWorld*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createWorld'", NULL);
#endif
  {
   b2World* tolua_ret = (b2World*)  self->createWorld();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"b2World");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createWorld'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DWorld */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DWorld_load00
static int tolua_MyGame_CC2DWorld_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DWorld* self = (CC2DWorld*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DBody */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DBody_new00
static int tolua_MyGame_CC2DBody_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DBody",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DBody* tolua_ret = (CC2DBody*)  Mtolua_new((CC2DBody)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DBody");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DBody */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DBody_new00_local
static int tolua_MyGame_CC2DBody_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DBody",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DBody* tolua_ret = (CC2DBody*)  Mtolua_new((CC2DBody)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DBody");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DBody */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DBody_delete00
static int tolua_MyGame_CC2DBody_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DBody",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DBody* self = (CC2DBody*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createBody of class  CC2DBody */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DBody_createBody00
static int tolua_MyGame_CC2DBody_createBody00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DBody",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"b2World",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DBody* self = (CC2DBody*)  tolua_tousertype(tolua_S,1,0);
  b2World* world = ((b2World*)  tolua_tousertype(tolua_S,2,0));
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createBody'", NULL);
#endif
  {
   b2Body* tolua_ret = (b2Body*)  self->createBody(world,pNode);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"b2Body");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createBody'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DBody */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DBody_load00
static int tolua_MyGame_CC2DBody_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DBody",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DBody* self = (CC2DBody*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DCircle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DCircle_new00
static int tolua_MyGame_CC2DCircle_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DCircle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DCircle* tolua_ret = (CC2DCircle*)  Mtolua_new((CC2DCircle)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DCircle");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DCircle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DCircle_new00_local
static int tolua_MyGame_CC2DCircle_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DCircle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DCircle* tolua_ret = (CC2DCircle*)  Mtolua_new((CC2DCircle)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DCircle");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DCircle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DCircle_delete00
static int tolua_MyGame_CC2DCircle_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DCircle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DCircle* self = (CC2DCircle*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DCircle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DCircle_load00
static int tolua_MyGame_CC2DCircle_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DCircle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CC2DNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DCircle* self = (CC2DCircle*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
  CC2DNode* pNode = ((CC2DNode*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser,pNode);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DRectangle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DRectangle_new00
static int tolua_MyGame_CC2DRectangle_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DRectangle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DRectangle* tolua_ret = (CC2DRectangle*)  Mtolua_new((CC2DRectangle)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DRectangle");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DRectangle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DRectangle_new00_local
static int tolua_MyGame_CC2DRectangle_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DRectangle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DRectangle* tolua_ret = (CC2DRectangle*)  Mtolua_new((CC2DRectangle)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DRectangle");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DRectangle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DRectangle_delete00
static int tolua_MyGame_CC2DRectangle_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DRectangle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DRectangle* self = (CC2DRectangle*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DRectangle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DRectangle_load00
static int tolua_MyGame_CC2DRectangle_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DRectangle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CC2DNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DRectangle* self = (CC2DRectangle*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
  CC2DNode* pNode = ((CC2DNode*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser,pNode);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DPolygon */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DPolygon_new00
static int tolua_MyGame_CC2DPolygon_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DPolygon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DPolygon* tolua_ret = (CC2DPolygon*)  Mtolua_new((CC2DPolygon)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DPolygon");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DPolygon */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DPolygon_new00_local
static int tolua_MyGame_CC2DPolygon_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DPolygon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DPolygon* tolua_ret = (CC2DPolygon*)  Mtolua_new((CC2DPolygon)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DPolygon");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DPolygon */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DPolygon_delete00
static int tolua_MyGame_CC2DPolygon_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DPolygon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DPolygon* self = (CC2DPolygon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DPolygon */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DPolygon_load00
static int tolua_MyGame_CC2DPolygon_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DPolygon",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CC2DNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DPolygon* self = (CC2DPolygon*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
  CC2DNode* pNode = ((CC2DNode*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser,pNode);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CCATFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CCATFileCache_new00
static int tolua_MyGame_CCATFileCache_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CCATFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CCATFileCache* tolua_ret = (CCATFileCache*)  Mtolua_new((CCATFileCache)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCATFileCache");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CCATFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CCATFileCache_new00_local
static int tolua_MyGame_CCATFileCache_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CCATFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CCATFileCache* tolua_ret = (CCATFileCache*)  Mtolua_new((CCATFileCache)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCATFileCache");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CCATFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CCATFileCache_delete00
static int tolua_MyGame_CCATFileCache_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CCATFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCATFileCache* self = (CCATFileCache*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sharedCCATFileCache of class  CCATFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CCATFileCache_sharedCCATFileCache00
static int tolua_MyGame_CCATFileCache_sharedCCATFileCache00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CCATFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CCATFileCache* tolua_ret = (CCATFileCache*)  CCATFileCache::sharedCCATFileCache();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCATFileCache");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sharedCCATFileCache'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findAction of class  CCATFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CCATFileCache_findAction00
static int tolua_MyGame_CCATFileCache_findAction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CCATFileCache",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCATFileCache* self = (CCATFileCache*)  tolua_tousertype(tolua_S,1,0);
  const char* actName = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* actFile = ((const char*)  tolua_tostring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findAction'", NULL);
#endif
  {
   CCAction* tolua_ret = (CCAction*)  self->findAction(actName,actFile);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findAction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_new00
static int tolua_MyGame_XmlParser_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* filename = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   XmlParser* tolua_ret = (XmlParser*)  Mtolua_new((XmlParser)(filename));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"XmlParser");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_new00_local
static int tolua_MyGame_XmlParser_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* filename = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   XmlParser* tolua_ret = (XmlParser*)  Mtolua_new((XmlParser)(filename));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"XmlParser");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_delete00
static int tolua_MyGame_XmlParser_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBoolForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getBoolForKey00
static int tolua_MyGame_XmlParser_getBoolForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  bool defaultValue = ((bool)  tolua_toboolean(tolua_S,4,false));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBoolForKey'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getBoolForKey(pKey,index,defaultValue);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBoolForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIntegerForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getIntegerForKey00
static int tolua_MyGame_XmlParser_getIntegerForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  int defautValue = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIntegerForKey'", NULL);
#endif
  {
   int tolua_ret = (int)  self->getIntegerForKey(pKey,index,defautValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIntegerForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIntArrayForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getIntArrayForKey00
static int tolua_MyGame_XmlParser_getIntArrayForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIntArrayForKey'", NULL);
#endif
  {
   std::vector<int> tolua_ret = (std::vector<int>)  self->getIntArrayForKey(pKey,index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIntArrayForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFloatArrayForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getFloatArrayForKey00
static int tolua_MyGame_XmlParser_getFloatArrayForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFloatArrayForKey'", NULL);
#endif
  {
   std::vector<float> tolua_ret = (std::vector<float>)  self->getFloatArrayForKey(pKey,index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFloatArrayForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFloatForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getFloatForKey00
static int tolua_MyGame_XmlParser_getFloatForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  float defautValue = ((float)  tolua_tonumber(tolua_S,4,0.0f));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFloatForKey'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getFloatForKey(pKey,index,defautValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFloatForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDoubleForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getDoubleForKey00
static int tolua_MyGame_XmlParser_getDoubleForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  double defautValue = ((double)  tolua_tonumber(tolua_S,4,0.0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDoubleForKey'", NULL);
#endif
  {
   double tolua_ret = (double)  self->getDoubleForKey(pKey,index,defautValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDoubleForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRectForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getRectForKey00
static int tolua_MyGame_XmlParser_getRectForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRectForKey'", NULL);
#endif
  {
   cocos2d::CCRect tolua_ret = (cocos2d::CCRect)  self->getRectForKey(pKey,index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCRect)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCRect));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRectForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRectForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getRectForKey01
static int tolua_MyGame_XmlParser_getRectForKey01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const cocos2d::CCRect",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  const cocos2d::CCRect* defaultRect = ((const cocos2d::CCRect*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRectForKey'", NULL);
#endif
  {
   cocos2d::CCRect tolua_ret = (cocos2d::CCRect)  self->getRectForKey(pKey,index,*defaultRect);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCRect)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCRect));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getRectForKey00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPointForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getPointForKey00
static int tolua_MyGame_XmlParser_getPointForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPointForKey'", NULL);
#endif
  {
   cocos2d::CCPoint tolua_ret = (cocos2d::CCPoint)  self->getPointForKey(pKey,index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCPoint)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCPoint));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPointForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPointForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getPointForKey01
static int tolua_MyGame_XmlParser_getPointForKey01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const cocos2d::CCPoint",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  const cocos2d::CCPoint* defaultPoint = ((const cocos2d::CCPoint*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPointForKey'", NULL);
#endif
  {
   cocos2d::CCPoint tolua_ret = (cocos2d::CCPoint)  self->getPointForKey(pKey,index,*defaultPoint);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCPoint)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCPoint));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getPointForKey00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSizeForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getSizeForKey00
static int tolua_MyGame_XmlParser_getSizeForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSizeForKey'", NULL);
#endif
  {
   cocos2d::CCSize tolua_ret = (cocos2d::CCSize)  self->getSizeForKey(pKey,index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCSize)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCSize));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSizeForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSizeForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getSizeForKey01
static int tolua_MyGame_XmlParser_getSizeForKey01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const cocos2d::CCSize",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  const cocos2d::CCSize* defaultSize = ((const cocos2d::CCSize*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSizeForKey'", NULL);
#endif
  {
   cocos2d::CCSize tolua_ret = (cocos2d::CCSize)  self->getSizeForKey(pKey,index,*defaultSize);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCSize)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCSize));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getSizeForKey00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getStringForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getStringForKey00
static int tolua_MyGame_XmlParser_getStringForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isstring(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  const char* defaultValue = ((const char*)  tolua_tostring(tolua_S,4,""));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getStringForKey'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getStringForKey(pKey,index,defaultValue);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getStringForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: gotoNextGroup of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_gotoNextGroup00
static int tolua_MyGame_XmlParser_gotoNextGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'gotoNextGroup'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->gotoNextGroup();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'gotoNextGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: gotoChildGroup of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_gotoChildGroup00
static int tolua_MyGame_XmlParser_gotoChildGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'gotoChildGroup'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->gotoChildGroup();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'gotoChildGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: curNodeName of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_curNodeName00
static int tolua_MyGame_XmlParser_curNodeName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'curNodeName'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->curNodeName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'curNodeName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: allPropertyNames of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_allPropertyNames00
static int tolua_MyGame_XmlParser_allPropertyNames00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'allPropertyNames'", NULL);
#endif
  {
   std::vector<std::string> tolua_ret = (std::vector<std::string>)  self->allPropertyNames();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<std::string>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<std::string>));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'allPropertyNames'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBoolForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setBoolForKey00
static int tolua_MyGame_XmlParser_setBoolForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  bool value = ((bool)  tolua_toboolean(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBoolForKey'", NULL);
#endif
  {
   self->setBoolForKey(pKey,value,index);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBoolForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setIntegerForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setIntegerForKey00
static int tolua_MyGame_XmlParser_setIntegerForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int value = ((int)  tolua_tonumber(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setIntegerForKey'", NULL);
#endif
  {
   self->setIntegerForKey(pKey,value,index);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setIntegerForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFloatForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setFloatForKey00
static int tolua_MyGame_XmlParser_setFloatForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  float value = ((float)  tolua_tonumber(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFloatForKey'", NULL);
#endif
  {
   self->setFloatForKey(pKey,value,index);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFloatForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDoubleForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setDoubleForKey00
static int tolua_MyGame_XmlParser_setDoubleForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  double value = ((double)  tolua_tonumber(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDoubleForKey'", NULL);
#endif
  {
   self->setDoubleForKey(pKey,value,index);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDoubleForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setStringForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setStringForKey00
static int tolua_MyGame_XmlParser_setStringForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  std::string value = ((std::string)  tolua_tocppstring(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStringForKey'", NULL);
#endif
  {
   self->setStringForKey(pKey,value,index);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setStringForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAtrribute of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setAtrribute00
static int tolua_MyGame_XmlParser_setAtrribute00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* value = ((const char*)  tolua_tostring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAtrribute'", NULL);
#endif
  {
   self->setAtrribute(pKey,value);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAtrribute'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAttribute of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getAttribute00
static int tolua_MyGame_XmlParser_getAttribute00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAttribute'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getAttribute(pKey);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAttribute'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIntegerForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getIntegerForAttr00
static int tolua_MyGame_XmlParser_getIntegerForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIntegerForAttr'", NULL);
#endif
  {
   int tolua_ret = (int)  self->getIntegerForAttr(pKey);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIntegerForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPointForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getPointForAttr00
static int tolua_MyGame_XmlParser_getPointForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPointForAttr'", NULL);
#endif
  {
   cocos2d::CCPoint tolua_ret = (cocos2d::CCPoint)  self->getPointForAttr(pKey);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCPoint)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCPoint));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPointForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPointForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getPointForAttr01
static int tolua_MyGame_XmlParser_getPointForAttr01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cocos2d::CCPoint",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  const cocos2d::CCPoint* defaultPoint = ((const cocos2d::CCPoint*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPointForAttr'", NULL);
#endif
  {
   cocos2d::CCPoint tolua_ret = (cocos2d::CCPoint)  self->getPointForAttr(pKey,*defaultPoint);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCPoint)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCPoint));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getPointForAttr00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRectForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getRectForAttr00
static int tolua_MyGame_XmlParser_getRectForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRectForAttr'", NULL);
#endif
  {
   cocos2d::CCRect tolua_ret = (cocos2d::CCRect)  self->getRectForAttr(pKey);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCRect)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCRect));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRectForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRectForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getRectForAttr01
static int tolua_MyGame_XmlParser_getRectForAttr01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cocos2d::CCRect",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  const cocos2d::CCRect* defaultRect = ((const cocos2d::CCRect*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRectForAttr'", NULL);
#endif
  {
   cocos2d::CCRect tolua_ret = (cocos2d::CCRect)  self->getRectForAttr(pKey,*defaultRect);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCRect)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCRect));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getRectForAttr00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSizeForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getSizeForAttr00
static int tolua_MyGame_XmlParser_getSizeForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSizeForAttr'", NULL);
#endif
  {
   cocos2d::CCSize tolua_ret = (cocos2d::CCSize)  self->getSizeForAttr(pKey);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCSize)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCSize));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSizeForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSizeForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getSizeForAttr01
static int tolua_MyGame_XmlParser_getSizeForAttr01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cocos2d::CCSize",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  const cocos2d::CCSize* defaultSize = ((const cocos2d::CCSize*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSizeForAttr'", NULL);
#endif
  {
   cocos2d::CCSize tolua_ret = (cocos2d::CCSize)  self->getSizeForAttr(pKey,*defaultSize);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCSize)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCSize));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getSizeForAttr00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColorForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getColorForAttr00
static int tolua_MyGame_XmlParser_getColorForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColorForAttr'", NULL);
#endif
  {
   cocos2d::ccColor4B tolua_ret = (cocos2d::ccColor4B)  self->getColorForAttr(pKey);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::ccColor4B)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::ccColor4B");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::ccColor4B));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::ccColor4B");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColorForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColorForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getColorForAttr01
static int tolua_MyGame_XmlParser_getColorForAttr01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cocos2d::ccColor4B",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  const cocos2d::ccColor4B* defaultColor = ((const cocos2d::ccColor4B*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColorForAttr'", NULL);
#endif
  {
   cocos2d::ccColor4B tolua_ret = (cocos2d::ccColor4B)  self->getColorForAttr(pKey,*defaultColor);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::ccColor4B)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::ccColor4B");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::ccColor4B));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::ccColor4B");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getColorForAttr00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDoubleForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getDoubleForAttr00
static int tolua_MyGame_XmlParser_getDoubleForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  double defaultValue = ((double)  tolua_tonumber(tolua_S,3,0.0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDoubleForAttr'", NULL);
#endif
  {
   double tolua_ret = (double)  self->getDoubleForAttr(pKey,defaultValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDoubleForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFloatForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getFloatForAttr00
static int tolua_MyGame_XmlParser_getFloatForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  float defaultValue = ((float)  tolua_tonumber(tolua_S,3,0.0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFloatForAttr'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getFloatForAttr(pKey,defaultValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFloatForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: beginGroup of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_beginGroup00
static int tolua_MyGame_XmlParser_beginGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* groupName = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'beginGroup'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->beginGroup(groupName,index);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'beginGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: endGroup of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_endGroup00
static int tolua_MyGame_XmlParser_endGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'endGroup'", NULL);
#endif
  {
   self->endGroup();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'endGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initXMLFile of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_initXMLFile00
static int tolua_MyGame_XmlParser_initXMLFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* filename = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initXMLFile'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->initXMLFile(filename);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initXMLFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: saveXMLFile of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_saveXMLFile00
static int tolua_MyGame_XmlParser_saveXMLFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'saveXMLFile'", NULL);
#endif
  {
   self->saveXMLFile();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'saveXMLFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reset of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_reset00
static int tolua_MyGame_XmlParser_reset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reset'", NULL);
#endif
  {
   self->reset();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isXMLFileExist of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_isXMLFileExist00
static int tolua_MyGame_XmlParser_isXMLFileExist00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* filename = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  XmlParser::isXMLFileExist(filename);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isXMLFileExist'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFileName of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getFileName00
static int tolua_MyGame_XmlParser_getFileName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFileName'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getFileName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFileName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: newGroup of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_newGroup00
static int tolua_MyGame_XmlParser_newGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* groupName = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'newGroup'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->newGroup(groupName);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'newGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createXMLFile of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_createXMLFile00
static int tolua_MyGame_XmlParser_createXMLFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* newFileName = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  XmlParser::createXMLFile(newFileName);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createXMLFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getXMLNodeForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getXMLNodeForKey00
static int tolua_MyGame_XmlParser_getXMLNodeForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"xmlNodePtr",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  xmlNodePtr parentNode = *((xmlNodePtr*)  tolua_tousertype(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getXMLNodeForKey'", NULL);
#endif
  {
   xmlNodePtr tolua_ret = (xmlNodePtr)  self->getXMLNodeForKey(pKey,parentNode,index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((xmlNodePtr)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"xmlNodePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(xmlNodePtr));
     tolua_pushusertype(tolua_S,tolua_obj,"xmlNodePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getXMLNodeForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getValueForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getValueForKey00
static int tolua_MyGame_XmlParser_getValueForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValueForKey'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getValueForKey(pKey,index);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getValueForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setValueForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setValueForKey00
static int tolua_MyGame_XmlParser_setValueForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* pValue = ((const char*)  tolua_tostring(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValueForKey'", NULL);
#endif
  {
   self->setValueForKey(pKey,pValue,index);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setValueForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_new00
static int tolua_MyGame_VSoundPlay_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VSoundPlay* tolua_ret = (VSoundPlay*)  Mtolua_new((VSoundPlay)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VSoundPlay");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_new00_local
static int tolua_MyGame_VSoundPlay_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VSoundPlay* tolua_ret = (VSoundPlay*)  Mtolua_new((VSoundPlay)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VSoundPlay");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_delete00
static int tolua_MyGame_VSoundPlay_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSoundPlay* self = (VSoundPlay*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initWithFile of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_initWithFile00
static int tolua_MyGame_VSoundPlay_initWithFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSoundPlay* self = (VSoundPlay*)  tolua_tousertype(tolua_S,1,0);
  const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
  float volume = ((float)  tolua_tonumber(tolua_S,3,1.0f));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initWithFile'", NULL);
#endif
  {
   self->initWithFile(path,volume);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initWithFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startWithTarget of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_startWithTarget00
static int tolua_MyGame_VSoundPlay_startWithTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSoundPlay* self = (VSoundPlay*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pTarget = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startWithTarget'", NULL);
#endif
  {
   self->startWithTarget(pTarget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'startWithTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reverse of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_reverse00
static int tolua_MyGame_VSoundPlay_reverse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSoundPlay* self = (VSoundPlay*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reverse'", NULL);
#endif
  {
   CCFiniteTimeAction* tolua_ret = (CCFiniteTimeAction*)  self->reverse();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCFiniteTimeAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reverse'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: copyWithZone of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_copyWithZone00
static int tolua_MyGame_VSoundPlay_copyWithZone00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCZone",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSoundPlay* self = (VSoundPlay*)  tolua_tousertype(tolua_S,1,0);
  CCZone* pZone = ((CCZone*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'copyWithZone'", NULL);
#endif
  {
   CCObject* tolua_ret = (CCObject*)  self->copyWithZone(pZone);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCObject");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'copyWithZone'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: action of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_action00
static int tolua_MyGame_VSoundPlay_action00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
  float volume = ((float)  tolua_tonumber(tolua_S,3,1.0f));
  {
   VSoundPlay* tolua_ret = (VSoundPlay*)  VSoundPlay::action(path,volume);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VSoundPlay");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'action'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_new00
static int tolua_MyGame_VDeleteNode_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VDeleteNode* tolua_ret = (VDeleteNode*)  Mtolua_new((VDeleteNode)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VDeleteNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_new00_local
static int tolua_MyGame_VDeleteNode_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VDeleteNode* tolua_ret = (VDeleteNode*)  Mtolua_new((VDeleteNode)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VDeleteNode");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_delete00
static int tolua_MyGame_VDeleteNode_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VDeleteNode* self = (VDeleteNode*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startWithTarget of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_startWithTarget00
static int tolua_MyGame_VDeleteNode_startWithTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VDeleteNode* self = (VDeleteNode*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pTarget = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startWithTarget'", NULL);
#endif
  {
   self->startWithTarget(pTarget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'startWithTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reverse of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_reverse00
static int tolua_MyGame_VDeleteNode_reverse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VDeleteNode* self = (VDeleteNode*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reverse'", NULL);
#endif
  {
   CCFiniteTimeAction* tolua_ret = (CCFiniteTimeAction*)  self->reverse();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCFiniteTimeAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reverse'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: copyWithZone of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_copyWithZone00
static int tolua_MyGame_VDeleteNode_copyWithZone00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCZone",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VDeleteNode* self = (VDeleteNode*)  tolua_tousertype(tolua_S,1,0);
  CCZone* pZone = ((CCZone*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'copyWithZone'", NULL);
#endif
  {
   CCObject* tolua_ret = (CCObject*)  self->copyWithZone(pZone);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCObject");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'copyWithZone'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: action of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_action00
static int tolua_MyGame_VDeleteNode_action00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VDeleteNode* tolua_ret = (VDeleteNode*)  VDeleteNode::action();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VDeleteNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'action'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_new00
static int tolua_MyGame_VSetGridNull_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VSetGridNull* tolua_ret = (VSetGridNull*)  Mtolua_new((VSetGridNull)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VSetGridNull");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_new00_local
static int tolua_MyGame_VSetGridNull_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VSetGridNull* tolua_ret = (VSetGridNull*)  Mtolua_new((VSetGridNull)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VSetGridNull");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_delete00
static int tolua_MyGame_VSetGridNull_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSetGridNull* self = (VSetGridNull*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startWithTarget of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_startWithTarget00
static int tolua_MyGame_VSetGridNull_startWithTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSetGridNull* self = (VSetGridNull*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pTarget = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startWithTarget'", NULL);
#endif
  {
   self->startWithTarget(pTarget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'startWithTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reverse of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_reverse00
static int tolua_MyGame_VSetGridNull_reverse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSetGridNull* self = (VSetGridNull*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reverse'", NULL);
#endif
  {
   CCFiniteTimeAction* tolua_ret = (CCFiniteTimeAction*)  self->reverse();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCFiniteTimeAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reverse'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: copyWithZone of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_copyWithZone00
static int tolua_MyGame_VSetGridNull_copyWithZone00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCZone",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSetGridNull* self = (VSetGridNull*)  tolua_tousertype(tolua_S,1,0);
  CCZone* pZone = ((CCZone*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'copyWithZone'", NULL);
#endif
  {
   CCObject* tolua_ret = (CCObject*)  self->copyWithZone(pZone);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCObject");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'copyWithZone'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: action of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_action00
static int tolua_MyGame_VSetGridNull_action00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VSetGridNull* tolua_ret = (VSetGridNull*)  VSetGridNull::action();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VSetGridNull");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'action'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_new00
static int tolua_MyGame_VNodeRunAction_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VNodeRunAction* tolua_ret = (VNodeRunAction*)  Mtolua_new((VNodeRunAction)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VNodeRunAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_new00_local
static int tolua_MyGame_VNodeRunAction_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VNodeRunAction* tolua_ret = (VNodeRunAction*)  Mtolua_new((VNodeRunAction)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VNodeRunAction");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_delete00
static int tolua_MyGame_VNodeRunAction_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VNodeRunAction* self = (VNodeRunAction*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startWithTarget of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_startWithTarget00
static int tolua_MyGame_VNodeRunAction_startWithTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VNodeRunAction* self = (VNodeRunAction*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pTarget = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startWithTarget'", NULL);
#endif
  {
   self->startWithTarget(pTarget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'startWithTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reverse of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_reverse00
static int tolua_MyGame_VNodeRunAction_reverse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VNodeRunAction* self = (VNodeRunAction*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reverse'", NULL);
#endif
  {
   CCFiniteTimeAction* tolua_ret = (CCFiniteTimeAction*)  self->reverse();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCFiniteTimeAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reverse'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: copyWithZone of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_copyWithZone00
static int tolua_MyGame_VNodeRunAction_copyWithZone00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCZone",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VNodeRunAction* self = (VNodeRunAction*)  tolua_tousertype(tolua_S,1,0);
  CCZone* pZone = ((CCZone*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'copyWithZone'", NULL);
#endif
  {
   CCObject* tolua_ret = (CCObject*)  self->copyWithZone(pZone);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCObject");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'copyWithZone'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initWithNodeName of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_initWithNodeName00
static int tolua_MyGame_VNodeRunAction_initWithNodeName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VNodeRunAction* self = (VNodeRunAction*)  tolua_tousertype(tolua_S,1,0);
  const char* nodeName = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* actName = ((const char*)  tolua_tostring(tolua_S,3,0));
  const char* ccatFile = ((const char*)  tolua_tostring(tolua_S,4,0));
  FindFromType findType = ((FindFromType) (int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initWithNodeName'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->initWithNodeName(nodeName,actName,ccatFile,findType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initWithNodeName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: actionWithNodeName of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_actionWithNodeName00
static int tolua_MyGame_VNodeRunAction_actionWithNodeName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* nodeName = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* actName = ((const char*)  tolua_tostring(tolua_S,3,0));
  const char* ccatFile = ((const char*)  tolua_tostring(tolua_S,4,0));
  FindFromType findType = ((FindFromType) (int)  tolua_tonumber(tolua_S,5,0));
  {
   VNodeRunAction* tolua_ret = (VNodeRunAction*)  VNodeRunAction::actionWithNodeName(nodeName,actName,ccatFile,findType);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VNodeRunAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'actionWithNodeName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_new00
static int tolua_MyGame_VCC2DLoad_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VCC2DLoad* tolua_ret = (VCC2DLoad*)  Mtolua_new((VCC2DLoad)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VCC2DLoad");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_new00_local
static int tolua_MyGame_VCC2DLoad_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VCC2DLoad* tolua_ret = (VCC2DLoad*)  Mtolua_new((VCC2DLoad)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VCC2DLoad");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_delete00
static int tolua_MyGame_VCC2DLoad_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VCC2DLoad* self = (VCC2DLoad*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startWithTarget of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_startWithTarget00
static int tolua_MyGame_VCC2DLoad_startWithTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VCC2DLoad* self = (VCC2DLoad*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pTarget = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startWithTarget'", NULL);
#endif
  {
   self->startWithTarget(pTarget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'startWithTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reverse of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_reverse00
static int tolua_MyGame_VCC2DLoad_reverse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VCC2DLoad* self = (VCC2DLoad*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reverse'", NULL);
#endif
  {
   CCFiniteTimeAction* tolua_ret = (CCFiniteTimeAction*)  self->reverse();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCFiniteTimeAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reverse'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: copyWithZone of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_copyWithZone00
static int tolua_MyGame_VCC2DLoad_copyWithZone00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCZone",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VCC2DLoad* self = (VCC2DLoad*)  tolua_tousertype(tolua_S,1,0);
  CCZone* pZone = ((CCZone*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'copyWithZone'", NULL);
#endif
  {
   CCObject* tolua_ret = (CCObject*)  self->copyWithZone(pZone);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCObject");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'copyWithZone'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initWithFile of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_initWithFile00
static int tolua_MyGame_VCC2DLoad_initWithFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VCC2DLoad* self = (VCC2DLoad*)  tolua_tousertype(tolua_S,1,0);
  const char* cc2dFile = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* parentNodeName = ((const char*)  tolua_tostring(tolua_S,3,0));
  FindFromType findType = ((FindFromType) (int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initWithFile'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->initWithFile(cc2dFile,parentNodeName,findType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initWithFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: actionWithFile of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_actionWithFile00
static int tolua_MyGame_VCC2DLoad_actionWithFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* cc2dFile = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* parentNodeName = ((const char*)  tolua_tostring(tolua_S,3,0));
  FindFromType findType = ((FindFromType) (int)  tolua_tonumber(tolua_S,4,0));
  {
   VCC2DLoad* tolua_ret = (VCC2DLoad*)  VCC2DLoad::actionWithFile(cc2dFile,parentNodeName,findType);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"VCC2DLoad");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'actionWithFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_new00
static int tolua_MyGame_SpriteExt_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   SpriteExt* tolua_ret = (SpriteExt*)  Mtolua_new((SpriteExt)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"SpriteExt");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_new00_local
static int tolua_MyGame_SpriteExt_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   SpriteExt* tolua_ret = (SpriteExt*)  Mtolua_new((SpriteExt)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"SpriteExt");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_delete00
static int tolua_MyGame_SpriteExt_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  SpriteExt* self = (SpriteExt*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: spriteWithFile of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_spriteWithFile00
static int tolua_MyGame_SpriteExt_spriteWithFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* pszFileName = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   SpriteExt* tolua_ret = (SpriteExt*)  SpriteExt::spriteWithFile(pszFileName);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"SpriteExt");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'spriteWithFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: spriteWithFile of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_spriteWithFile01
static int tolua_MyGame_SpriteExt_spriteWithFile01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const CCRect",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const char* pszFileName = ((const char*)  tolua_tostring(tolua_S,2,0));
  const CCRect* rect = ((const CCRect*)  tolua_tousertype(tolua_S,3,0));
  {
   SpriteExt* tolua_ret = (SpriteExt*)  SpriteExt::spriteWithFile(pszFileName,*rect);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"SpriteExt");
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_SpriteExt_spriteWithFile00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFlag of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_getFlag00
static int tolua_MyGame_SpriteExt_getFlag00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const SpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const SpriteExt* self = (const SpriteExt*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFlag'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getFlag();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFlag'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFlag of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_setFlag00
static int tolua_MyGame_SpriteExt_setFlag00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  SpriteExt* self = (SpriteExt*)  tolua_tousertype(tolua_S,1,0);
  const std::string strFlag = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFlag'", NULL);
#endif
  {
   self->setFlag(strFlag);
   tolua_pushcppstring(tolua_S,(const char*)strFlag);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFlag'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDispearAction of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_setDispearAction00
static int tolua_MyGame_SpriteExt_setDispearAction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  SpriteExt* self = (SpriteExt*)  tolua_tousertype(tolua_S,1,0);
  const std::string dispearAction = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDispearAction'", NULL);
#endif
  {
   self->setDispearAction(dispearAction);
   tolua_pushcppstring(tolua_S,(const char*)dispearAction);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDispearAction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCcatFile of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_setCcatFile00
static int tolua_MyGame_SpriteExt_setCcatFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  SpriteExt* self = (SpriteExt*)  tolua_tousertype(tolua_S,1,0);
  const std::string ccatFile = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCcatFile'", NULL);
#endif
  {
   self->setCcatFile(ccatFile);
   tolua_pushcppstring(tolua_S,(const char*)ccatFile);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCcatFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: dispear of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_dispear00
static int tolua_MyGame_SpriteExt_dispear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  SpriteExt* self = (SpriteExt*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dispear'", NULL);
#endif
  {
   self->dispear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'dispear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildByName of class  Misc */
#ifndef TOLUA_DISABLE_tolua_MyGame_Misc_getChildByName00
static int tolua_MyGame_Misc_getChildByName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Misc",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
  const char* nodeName = ((const char*)  tolua_tostring(tolua_S,3,0));
  {
   CCNode* tolua_ret = (CCNode*)  Misc::getChildByName(pNode,nodeName);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getChildByName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNodeName of class  Misc */
#ifndef TOLUA_DISABLE_tolua_MyGame_Misc_getNodeName00
static int tolua_MyGame_Misc_getNodeName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Misc",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
  {
   std::string tolua_ret = (std::string)  Misc::getNodeName(pNode);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNodeName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNodeName of class  Misc */
#ifndef TOLUA_DISABLE_tolua_MyGame_Misc_setNodeName00
static int tolua_MyGame_Misc_setNodeName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Misc",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
  const char* name = ((const char*)  tolua_tostring(tolua_S,3,0));
  {
   Misc::setNodeName(pNode,name);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNodeName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUserData of class  Misc */
#ifndef TOLUA_DISABLE_tolua_MyGame_Misc_getUserData00
static int tolua_MyGame_Misc_getUserData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Misc",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
  {
   void* tolua_ret = (void*)  Misc::getUserData(pNode);
   tolua_pushuserdata(tolua_S,(void*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUserData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: log of class  Misc */
#ifndef TOLUA_DISABLE_tolua_MyGame_Misc_log00
static int tolua_MyGame_Misc_log00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Misc",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* msg = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   Misc::log(msg);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'log'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fullPathFile of class  Misc */
#ifndef TOLUA_DISABLE_tolua_MyGame_Misc_fullPathFile00
static int tolua_MyGame_Misc_fullPathFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Misc",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* filename = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   std::string tolua_ret = (std::string)  Misc::fullPathFile(filename);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fullPathFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getInstancePtr of class  CNetManager */
#ifndef TOLUA_DISABLE_tolua_MyGame_CNetManager_getInstancePtr00
static int tolua_MyGame_CNetManager_getInstancePtr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CNetManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CNetManager* tolua_ret = (CNetManager*)  CNetManager::getInstancePtr();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CNetManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInstancePtr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: checkLogin of class  CNetManager */
#ifndef TOLUA_DISABLE_tolua_MyGame_CNetManager_checkLogin00
static int tolua_MyGame_CNetManager_checkLogin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CNetManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CNetManager* self = (CNetManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'checkLogin'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->checkLogin();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'checkLogin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: loginServer of class  CNetManager */
#ifndef TOLUA_DISABLE_tolua_MyGame_CNetManager_loginServer00
static int tolua_MyGame_CNetManager_loginServer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CNetManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CNetManager* self = (CNetManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string hostname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const int port = ((const int)  tolua_tonumber(tolua_S,3,0));
  const std::string userName = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
  const std::string password = ((const std::string)  tolua_tocppstring(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loginServer'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->loginServer(hostname,port,userName,password);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loginServer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: logoutServer of class  CNetManager */
#ifndef TOLUA_DISABLE_tolua_MyGame_CNetManager_logoutServer00
static int tolua_MyGame_CNetManager_logoutServer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CNetManager",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CNetManager* self = (CNetManager*)  tolua_tousertype(tolua_S,1,0);
  int force = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'logoutServer'", NULL);
#endif
  {
   self->logoutServer(force);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'logoutServer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getConnectionState of class  CNetManager */
#ifndef TOLUA_DISABLE_tolua_MyGame_CNetManager_getConnectionState00
static int tolua_MyGame_CNetManager_getConnectionState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CNetManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CNetManager* self = (CNetManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getConnectionState'", NULL);
#endif
  {
   sgs_connection_state tolua_ret = (sgs_connection_state)  self->getConnectionState();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((sgs_connection_state)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"sgs_connection_state");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(sgs_connection_state));
     tolua_pushusertype(tolua_S,tolua_obj,"sgs_connection_state");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getConnectionState'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sendMsg of class  CNetManager */
#ifndef TOLUA_DISABLE_tolua_MyGame_CNetManager_sendMsg00
static int tolua_MyGame_CNetManager_sendMsg00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CNetManager",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"size_t",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CNetManager* self = (CNetManager*)  tolua_tousertype(tolua_S,1,0);
  unsigned const char msg = ((unsigned const char)  tolua_tonumber(tolua_S,2,0));
  size_t msgLen = *((size_t*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sendMsg'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->sendMsg(&msg,msgLen);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushnumber(tolua_S,(lua_Number)msg);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sendMsg'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sendChannelMsg of class  CNetManager */
#ifndef TOLUA_DISABLE_tolua_MyGame_CNetManager_sendChannelMsg00
static int tolua_MyGame_CNetManager_sendChannelMsg00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CNetManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"size_t",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CNetManager* self = (CNetManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string channelName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  unsigned const char msg = ((unsigned const char)  tolua_tonumber(tolua_S,3,0));
  size_t msgLen = *((size_t*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sendChannelMsg'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->sendChannelMsg(channelName,&msg,msgLen);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushnumber(tolua_S,(lua_Number)msg);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sendChannelMsg'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: joinChannel of class  CNetManager */
#ifndef TOLUA_DISABLE_tolua_MyGame_CNetManager_joinChannel00
static int tolua_MyGame_CNetManager_joinChannel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CNetManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CNetManager* self = (CNetManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string channelName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'joinChannel'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->joinChannel(channelName);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'joinChannel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: leaveChannel of class  CNetManager */
#ifndef TOLUA_DISABLE_tolua_MyGame_CNetManager_leaveChannel00
static int tolua_MyGame_CNetManager_leaveChannel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CNetManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CNetManager* self = (CNetManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string channelName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'leaveChannel'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->leaveChannel(channelName);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'leaveChannel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: tick of class  CNetManager */
#ifndef TOLUA_DISABLE_tolua_MyGame_CNetManager_tick00
static int tolua_MyGame_CNetManager_tick00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CNetManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CNetManager* self = (CNetManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tick'", NULL);
#endif
  {
   self->tick();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'tick'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getInstancePtr of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_getInstancePtr00
static int tolua_MyGame_CPlayerMsgProcess_getInstancePtr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CPlayerMsgProcess* tolua_ret = (CPlayerMsgProcess*)  CPlayerMsgProcess::getInstancePtr();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CPlayerMsgProcess");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInstancePtr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setReceiveFunc of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_setReceiveFunc00
static int tolua_MyGame_CPlayerMsgProcess_setReceiveFunc00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isfunction(tolua_S,2,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
  int nHandler = (tolua_ref_function(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setReceiveFunc'", NULL);
#endif
  {
   self->setReceiveFunc(nHandler);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setReceiveFunc'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSendFunc of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_setSendFunc00
static int tolua_MyGame_CPlayerMsgProcess_setSendFunc00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isfunction(tolua_S,2,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
  int nHandler = (tolua_ref_function(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSendFunc'", NULL);
#endif
  {
   self->setSendFunc(nHandler);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSendFunc'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: processMsg of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_processMsg00
static int tolua_MyGame_CPlayerMsgProcess_processMsg00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"size_t",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
  unsigned const char msg = ((unsigned const char)  tolua_tonumber(tolua_S,2,0));
  size_t msglen = *((size_t*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'processMsg'", NULL);
#endif
  {
   self->processMsg(&msg,msglen);
   tolua_pushnumber(tolua_S,(lua_Number)msg);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'processMsg'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sendMsg of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_sendMsg00
static int tolua_MyGame_CPlayerMsgProcess_sendMsg00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
  unsigned const short msgType = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sendMsg'", NULL);
#endif
  {
   self->sendMsg(msgType);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sendMsg'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeInt8 of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_writeInt800
static int tolua_MyGame_CPlayerMsgProcess_writeInt800(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
  signed const char i8 = ((signed const char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeInt8'", NULL);
#endif
  {
   self->writeInt8(i8);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeInt8'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeInt32 of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_writeInt3200
static int tolua_MyGame_CPlayerMsgProcess_writeInt3200(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
  signed const int i32 = ((signed const int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeInt32'", NULL);
#endif
  {
   self->writeInt32(i32);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeInt32'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeInt16 of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_writeInt1600
static int tolua_MyGame_CPlayerMsgProcess_writeInt1600(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
  signed const short i16 = ((signed const short)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeInt16'", NULL);
#endif
  {
   self->writeInt16(i16);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeInt16'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeUint32 of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_writeUint3200
static int tolua_MyGame_CPlayerMsgProcess_writeUint3200(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
  unsigned const int u32 = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeUint32'", NULL);
#endif
  {
   self->writeUint32(u32);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeUint32'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeUint16 of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_writeUint1600
static int tolua_MyGame_CPlayerMsgProcess_writeUint1600(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
  unsigned const short u16 = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeUint16'", NULL);
#endif
  {
   self->writeUint16(u16);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeUint16'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeFloat of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_writeFloat00
static int tolua_MyGame_CPlayerMsgProcess_writeFloat00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
  const float f = ((const float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeFloat'", NULL);
#endif
  {
   self->writeFloat(f);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeFloat'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeDouble of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_writeDouble00
static int tolua_MyGame_CPlayerMsgProcess_writeDouble00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
  const double d = ((const double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeDouble'", NULL);
#endif
  {
   self->writeDouble(d);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeDouble'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readInt8 of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_readInt800
static int tolua_MyGame_CPlayerMsgProcess_readInt800(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readInt8'", NULL);
#endif
  {
   signed char tolua_ret = ( signed char)  self->readInt8();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readInt8'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readInt32 of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_readInt3200
static int tolua_MyGame_CPlayerMsgProcess_readInt3200(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readInt32'", NULL);
#endif
  {
   signed int tolua_ret = ( signed int)  self->readInt32();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readInt32'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readInt16 of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_readInt1600
static int tolua_MyGame_CPlayerMsgProcess_readInt1600(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readInt16'", NULL);
#endif
  {
   signed short tolua_ret = ( signed short)  self->readInt16();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readInt16'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readUint32 of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_readUint3200
static int tolua_MyGame_CPlayerMsgProcess_readUint3200(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readUint32'", NULL);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->readUint32();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readUint32'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readUint16 of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_readUint1600
static int tolua_MyGame_CPlayerMsgProcess_readUint1600(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readUint16'", NULL);
#endif
  {
   unsigned short tolua_ret = ( unsigned short)  self->readUint16();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readUint16'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readFloat of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_readFloat00
static int tolua_MyGame_CPlayerMsgProcess_readFloat00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readFloat'", NULL);
#endif
  {
   float tolua_ret = (float)  self->readFloat();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readFloat'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readDouble of class  CPlayerMsgProcess */
#ifndef TOLUA_DISABLE_tolua_MyGame_CPlayerMsgProcess_readDouble00
static int tolua_MyGame_CPlayerMsgProcess_readDouble00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CPlayerMsgProcess",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CPlayerMsgProcess* self = (CPlayerMsgProcess*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readDouble'", NULL);
#endif
  {
   double tolua_ret = (double)  self->readDouble();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readDouble'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  UIWidget */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIWidget_new00
static int tolua_MyGame_UIWidget_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"UIWidget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   UIWidget* tolua_ret = (UIWidget*)  Mtolua_new((UIWidget)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"UIWidget");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  UIWidget */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIWidget_new00_local
static int tolua_MyGame_UIWidget_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"UIWidget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   UIWidget* tolua_ret = (UIWidget*)  Mtolua_new((UIWidget)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"UIWidget");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  UIWidget */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIWidget_delete00
static int tolua_MyGame_UIWidget_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIWidget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIWidget* self = (UIWidget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: init of class  UIWidget */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIWidget_init00
static int tolua_MyGame_UIWidget_init00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIWidget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIWidget* self = (UIWidget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'init'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->init();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'init'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  UIWidget */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIWidget_create00
static int tolua_MyGame_UIWidget_create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"UIWidget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   UIWidget* tolua_ret = (UIWidget*)  UIWidget::create();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"UIWidget");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_new00
static int tolua_MyGame_UIButton_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   UIButton* tolua_ret = (UIButton*)  Mtolua_new((UIButton)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"UIButton");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_new00_local
static int tolua_MyGame_UIButton_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   UIButton* tolua_ret = (UIButton*)  Mtolua_new((UIButton)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"UIButton");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_delete00
static int tolua_MyGame_UIButton_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIButton* self = (UIButton*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_create00
static int tolua_MyGame_UIButton_create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,1,&tolua_err) ||
     !tolua_isstring(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* normalFile = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* selectedFile = ((const char*)  tolua_tostring(tolua_S,3,NULL));
  const char* disabledFile = ((const char*)  tolua_tostring(tolua_S,4,NULL));
  {
   UIButton* tolua_ret = (UIButton*)  UIButton::create(normalFile,selectedFile,disabledFile);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"UIButton");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initWithNormalImage of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_initWithNormalImage00
static int tolua_MyGame_UIButton_initWithNormalImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,1,&tolua_err) ||
     !tolua_isstring(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIButton* self = (UIButton*)  tolua_tousertype(tolua_S,1,0);
  const char* normalFile = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* selectedFile = ((const char*)  tolua_tostring(tolua_S,3,NULL));
  const char* disabledFile = ((const char*)  tolua_tostring(tolua_S,4,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initWithNormalImage'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->initWithNormalImage(normalFile,selectedFile,disabledFile);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initWithNormalImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: registerScriptActiveHandler of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_registerScriptActiveHandler00
static int tolua_MyGame_UIButton_registerScriptActiveHandler00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIButton",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isfunction(tolua_S,2,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIButton* self = (UIButton*)  tolua_tousertype(tolua_S,1,0);
  int nHandler = (tolua_ref_function(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'registerScriptActiveHandler'", NULL);
#endif
  {
   self->registerScriptActiveHandler(nHandler);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'registerScriptActiveHandler'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: unregisterScriptActiveHandler of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_unregisterScriptActiveHandler00
static int tolua_MyGame_UIButton_unregisterScriptActiveHandler00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIButton* self = (UIButton*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unregisterScriptActiveHandler'", NULL);
#endif
  {
   self->unregisterScriptActiveHandler();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'unregisterScriptActiveHandler'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: activate of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_activate00
static int tolua_MyGame_UIButton_activate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIButton* self = (UIButton*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'activate'", NULL);
#endif
  {
   self->activate();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'activate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_MyGame_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DFileCache","CC2DFileCache","CCObject",tolua_collect_CC2DFileCache);
  #else
  tolua_cclass(tolua_S,"CC2DFileCache","CC2DFileCache","CCObject",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DFileCache");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DFileCache_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DFileCache_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DFileCache_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DFileCache_delete00);
   tolua_function(tolua_S,"sharedCC2DFileCache",tolua_MyGame_CC2DFileCache_sharedCC2DFileCache00);
   tolua_function(tolua_S,"addCC2DNode",tolua_MyGame_CC2DFileCache_addCC2DNode00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DNode","CC2DNode","CCObject",tolua_collect_CC2DNode);
  #else
  tolua_cclass(tolua_S,"CC2DNode","CC2DNode","CCObject",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DNode");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DNode_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DNode_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DNode_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DNode_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DNode_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DNode_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DNode_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DSprite","CC2DSprite","CC2DNode",tolua_collect_CC2DSprite);
  #else
  tolua_cclass(tolua_S,"CC2DSprite","CC2DSprite","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DSprite");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DSprite_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DSprite_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DSprite_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DSprite_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DSprite_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DSprite_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DSprite_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DParticleSystem","CC2DParticleSystem","CC2DNode",tolua_collect_CC2DParticleSystem);
  #else
  tolua_cclass(tolua_S,"CC2DParticleSystem","CC2DParticleSystem","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DParticleSystem");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DParticleSystem_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DParticleSystem_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DParticleSystem_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DParticleSystem_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DParticleSystem_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DParticleSystem_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DParticleSystem_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DLayer","CC2DLayer","CC2DNode",tolua_collect_CC2DLayer);
  #else
  tolua_cclass(tolua_S,"CC2DLayer","CC2DLayer","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DLayer");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DLayer_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DLayer_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DLayer_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DLayer_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DLayer_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DLayer_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DLayer_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DProgressTimer","CC2DProgressTimer","CC2DNode",tolua_collect_CC2DProgressTimer);
  #else
  tolua_cclass(tolua_S,"CC2DProgressTimer","CC2DProgressTimer","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DProgressTimer");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DProgressTimer_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DProgressTimer_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DProgressTimer_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DProgressTimer_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DProgressTimer_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DProgressTimer_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DProgressTimer_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DParallaxNode","CC2DParallaxNode","CC2DNode",tolua_collect_CC2DParallaxNode);
  #else
  tolua_cclass(tolua_S,"CC2DParallaxNode","CC2DParallaxNode","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DParallaxNode");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DParallaxNode_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DParallaxNode_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DParallaxNode_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DParallaxNode_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DParallaxNode_createCCNode00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DScene","CC2DScene","CC2DNode",tolua_collect_CC2DScene);
  #else
  tolua_cclass(tolua_S,"CC2DScene","CC2DScene","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DScene");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DScene_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DScene_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DScene_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DScene_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DScene_createCCNode00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DMenu","CC2DMenu","CC2DNode",tolua_collect_CC2DMenu);
  #else
  tolua_cclass(tolua_S,"CC2DMenu","CC2DMenu","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DMenu");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DMenu_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DMenu_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DMenu_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DMenu_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DMenu_createCCNode00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DMenuItemImage","CC2DMenuItemImage","CC2DNode",tolua_collect_CC2DMenuItemImage);
  #else
  tolua_cclass(tolua_S,"CC2DMenuItemImage","CC2DMenuItemImage","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DMenuItemImage");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DMenuItemImage_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DMenuItemImage_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DMenuItemImage_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DMenuItemImage_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DMenuItemImage_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DMenuItemImage_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DMenuItemImage_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DSpriteExt","CC2DSpriteExt","CC2DSprite",tolua_collect_CC2DSpriteExt);
  #else
  tolua_cclass(tolua_S,"CC2DSpriteExt","CC2DSpriteExt","CC2DSprite",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DSpriteExt");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DSpriteExt_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DSpriteExt_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DSpriteExt_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DSpriteExt_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DSpriteExt_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DSpriteExt_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DSpriteExt_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DWorld","CC2DWorld","CCObject",tolua_collect_CC2DWorld);
  #else
  tolua_cclass(tolua_S,"CC2DWorld","CC2DWorld","CCObject",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DWorld");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DWorld_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DWorld_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DWorld_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DWorld_delete00);
   tolua_function(tolua_S,"createWorld",tolua_MyGame_CC2DWorld_createWorld00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DWorld_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DBody","CC2DBody","CCObject",tolua_collect_CC2DBody);
  #else
  tolua_cclass(tolua_S,"CC2DBody","CC2DBody","CCObject",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DBody");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DBody_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DBody_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DBody_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DBody_delete00);
   tolua_function(tolua_S,"createBody",tolua_MyGame_CC2DBody_createBody00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DBody_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DCircle","CC2DCircle","CC2DFixture",tolua_collect_CC2DCircle);
  #else
  tolua_cclass(tolua_S,"CC2DCircle","CC2DCircle","CC2DFixture",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DCircle");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DCircle_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DCircle_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DCircle_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DCircle_delete00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DCircle_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DRectangle","CC2DRectangle","CC2DFixture",tolua_collect_CC2DRectangle);
  #else
  tolua_cclass(tolua_S,"CC2DRectangle","CC2DRectangle","CC2DFixture",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DRectangle");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DRectangle_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DRectangle_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DRectangle_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DRectangle_delete00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DRectangle_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DPolygon","CC2DPolygon","CC2DFixture",tolua_collect_CC2DPolygon);
  #else
  tolua_cclass(tolua_S,"CC2DPolygon","CC2DPolygon","CC2DFixture",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DPolygon");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DPolygon_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DPolygon_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DPolygon_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DPolygon_delete00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DPolygon_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CCATFileCache","CCATFileCache","CCObject",tolua_collect_CCATFileCache);
  #else
  tolua_cclass(tolua_S,"CCATFileCache","CCATFileCache","CCObject",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CCATFileCache");
   tolua_function(tolua_S,"new",tolua_MyGame_CCATFileCache_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CCATFileCache_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CCATFileCache_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CCATFileCache_delete00);
   tolua_function(tolua_S,"sharedCCATFileCache",tolua_MyGame_CCATFileCache_sharedCCATFileCache00);
   tolua_function(tolua_S,"findAction",tolua_MyGame_CCATFileCache_findAction00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"XmlParser","XmlParser","",tolua_collect_XmlParser);
  #else
  tolua_cclass(tolua_S,"XmlParser","XmlParser","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"XmlParser");
   tolua_function(tolua_S,"new",tolua_MyGame_XmlParser_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_XmlParser_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_XmlParser_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_XmlParser_delete00);
   tolua_function(tolua_S,"getBoolForKey",tolua_MyGame_XmlParser_getBoolForKey00);
   tolua_function(tolua_S,"getIntegerForKey",tolua_MyGame_XmlParser_getIntegerForKey00);
   tolua_function(tolua_S,"getIntArrayForKey",tolua_MyGame_XmlParser_getIntArrayForKey00);
   tolua_function(tolua_S,"getFloatArrayForKey",tolua_MyGame_XmlParser_getFloatArrayForKey00);
   tolua_function(tolua_S,"getFloatForKey",tolua_MyGame_XmlParser_getFloatForKey00);
   tolua_function(tolua_S,"getDoubleForKey",tolua_MyGame_XmlParser_getDoubleForKey00);
   tolua_function(tolua_S,"getRectForKey",tolua_MyGame_XmlParser_getRectForKey00);
   tolua_function(tolua_S,"getRectForKey",tolua_MyGame_XmlParser_getRectForKey01);
   tolua_function(tolua_S,"getPointForKey",tolua_MyGame_XmlParser_getPointForKey00);
   tolua_function(tolua_S,"getPointForKey",tolua_MyGame_XmlParser_getPointForKey01);
   tolua_function(tolua_S,"getSizeForKey",tolua_MyGame_XmlParser_getSizeForKey00);
   tolua_function(tolua_S,"getSizeForKey",tolua_MyGame_XmlParser_getSizeForKey01);
   tolua_function(tolua_S,"getStringForKey",tolua_MyGame_XmlParser_getStringForKey00);
   tolua_function(tolua_S,"gotoNextGroup",tolua_MyGame_XmlParser_gotoNextGroup00);
   tolua_function(tolua_S,"gotoChildGroup",tolua_MyGame_XmlParser_gotoChildGroup00);
   tolua_function(tolua_S,"curNodeName",tolua_MyGame_XmlParser_curNodeName00);
   tolua_function(tolua_S,"allPropertyNames",tolua_MyGame_XmlParser_allPropertyNames00);
   tolua_function(tolua_S,"setBoolForKey",tolua_MyGame_XmlParser_setBoolForKey00);
   tolua_function(tolua_S,"setIntegerForKey",tolua_MyGame_XmlParser_setIntegerForKey00);
   tolua_function(tolua_S,"setFloatForKey",tolua_MyGame_XmlParser_setFloatForKey00);
   tolua_function(tolua_S,"setDoubleForKey",tolua_MyGame_XmlParser_setDoubleForKey00);
   tolua_function(tolua_S,"setStringForKey",tolua_MyGame_XmlParser_setStringForKey00);
   tolua_function(tolua_S,"setAtrribute",tolua_MyGame_XmlParser_setAtrribute00);
   tolua_function(tolua_S,"getAttribute",tolua_MyGame_XmlParser_getAttribute00);
   tolua_function(tolua_S,"getIntegerForAttr",tolua_MyGame_XmlParser_getIntegerForAttr00);
   tolua_function(tolua_S,"getPointForAttr",tolua_MyGame_XmlParser_getPointForAttr00);
   tolua_function(tolua_S,"getPointForAttr",tolua_MyGame_XmlParser_getPointForAttr01);
   tolua_function(tolua_S,"getRectForAttr",tolua_MyGame_XmlParser_getRectForAttr00);
   tolua_function(tolua_S,"getRectForAttr",tolua_MyGame_XmlParser_getRectForAttr01);
   tolua_function(tolua_S,"getSizeForAttr",tolua_MyGame_XmlParser_getSizeForAttr00);
   tolua_function(tolua_S,"getSizeForAttr",tolua_MyGame_XmlParser_getSizeForAttr01);
   tolua_function(tolua_S,"getColorForAttr",tolua_MyGame_XmlParser_getColorForAttr00);
   tolua_function(tolua_S,"getColorForAttr",tolua_MyGame_XmlParser_getColorForAttr01);
   tolua_function(tolua_S,"getDoubleForAttr",tolua_MyGame_XmlParser_getDoubleForAttr00);
   tolua_function(tolua_S,"getFloatForAttr",tolua_MyGame_XmlParser_getFloatForAttr00);
   tolua_function(tolua_S,"beginGroup",tolua_MyGame_XmlParser_beginGroup00);
   tolua_function(tolua_S,"endGroup",tolua_MyGame_XmlParser_endGroup00);
   tolua_function(tolua_S,"initXMLFile",tolua_MyGame_XmlParser_initXMLFile00);
   tolua_function(tolua_S,"saveXMLFile",tolua_MyGame_XmlParser_saveXMLFile00);
   tolua_function(tolua_S,"reset",tolua_MyGame_XmlParser_reset00);
   tolua_function(tolua_S,"isXMLFileExist",tolua_MyGame_XmlParser_isXMLFileExist00);
   tolua_function(tolua_S,"getFileName",tolua_MyGame_XmlParser_getFileName00);
   tolua_function(tolua_S,"newGroup",tolua_MyGame_XmlParser_newGroup00);
   tolua_function(tolua_S,"createXMLFile",tolua_MyGame_XmlParser_createXMLFile00);
   tolua_function(tolua_S,"getXMLNodeForKey",tolua_MyGame_XmlParser_getXMLNodeForKey00);
   tolua_function(tolua_S,"getValueForKey",tolua_MyGame_XmlParser_getValueForKey00);
   tolua_function(tolua_S,"setValueForKey",tolua_MyGame_XmlParser_setValueForKey00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"VSoundPlay","VSoundPlay","CCActionInstant",tolua_collect_VSoundPlay);
  #else
  tolua_cclass(tolua_S,"VSoundPlay","VSoundPlay","CCActionInstant",NULL);
  #endif
  tolua_beginmodule(tolua_S,"VSoundPlay");
   tolua_function(tolua_S,"new",tolua_MyGame_VSoundPlay_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_VSoundPlay_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_VSoundPlay_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_VSoundPlay_delete00);
   tolua_function(tolua_S,"initWithFile",tolua_MyGame_VSoundPlay_initWithFile00);
   tolua_function(tolua_S,"startWithTarget",tolua_MyGame_VSoundPlay_startWithTarget00);
   tolua_function(tolua_S,"reverse",tolua_MyGame_VSoundPlay_reverse00);
   tolua_function(tolua_S,"copyWithZone",tolua_MyGame_VSoundPlay_copyWithZone00);
   tolua_function(tolua_S,"action",tolua_MyGame_VSoundPlay_action00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"VDeleteNode","VDeleteNode","CCActionInstant",tolua_collect_VDeleteNode);
  #else
  tolua_cclass(tolua_S,"VDeleteNode","VDeleteNode","CCActionInstant",NULL);
  #endif
  tolua_beginmodule(tolua_S,"VDeleteNode");
   tolua_function(tolua_S,"new",tolua_MyGame_VDeleteNode_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_VDeleteNode_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_VDeleteNode_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_VDeleteNode_delete00);
   tolua_function(tolua_S,"startWithTarget",tolua_MyGame_VDeleteNode_startWithTarget00);
   tolua_function(tolua_S,"reverse",tolua_MyGame_VDeleteNode_reverse00);
   tolua_function(tolua_S,"copyWithZone",tolua_MyGame_VDeleteNode_copyWithZone00);
   tolua_function(tolua_S,"action",tolua_MyGame_VDeleteNode_action00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"VSetGridNull","VSetGridNull","CCActionInstant",tolua_collect_VSetGridNull);
  #else
  tolua_cclass(tolua_S,"VSetGridNull","VSetGridNull","CCActionInstant",NULL);
  #endif
  tolua_beginmodule(tolua_S,"VSetGridNull");
   tolua_function(tolua_S,"new",tolua_MyGame_VSetGridNull_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_VSetGridNull_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_VSetGridNull_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_VSetGridNull_delete00);
   tolua_function(tolua_S,"startWithTarget",tolua_MyGame_VSetGridNull_startWithTarget00);
   tolua_function(tolua_S,"reverse",tolua_MyGame_VSetGridNull_reverse00);
   tolua_function(tolua_S,"copyWithZone",tolua_MyGame_VSetGridNull_copyWithZone00);
   tolua_function(tolua_S,"action",tolua_MyGame_VSetGridNull_action00);
  tolua_endmodule(tolua_S);
  tolua_constant(tolua_S,"FindFrom_Sefl",FindFrom_Sefl);
  tolua_constant(tolua_S,"FindFrom_Parent",FindFrom_Parent);
  tolua_constant(tolua_S,"FindFrom_Global",FindFrom_Global);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"VNodeRunAction","VNodeRunAction","CCActionInstant",tolua_collect_VNodeRunAction);
  #else
  tolua_cclass(tolua_S,"VNodeRunAction","VNodeRunAction","CCActionInstant",NULL);
  #endif
  tolua_beginmodule(tolua_S,"VNodeRunAction");
   tolua_function(tolua_S,"new",tolua_MyGame_VNodeRunAction_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_VNodeRunAction_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_VNodeRunAction_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_VNodeRunAction_delete00);
   tolua_function(tolua_S,"startWithTarget",tolua_MyGame_VNodeRunAction_startWithTarget00);
   tolua_function(tolua_S,"reverse",tolua_MyGame_VNodeRunAction_reverse00);
   tolua_function(tolua_S,"copyWithZone",tolua_MyGame_VNodeRunAction_copyWithZone00);
   tolua_function(tolua_S,"initWithNodeName",tolua_MyGame_VNodeRunAction_initWithNodeName00);
   tolua_function(tolua_S,"actionWithNodeName",tolua_MyGame_VNodeRunAction_actionWithNodeName00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"VCC2DLoad","VCC2DLoad","CCActionInstant",tolua_collect_VCC2DLoad);
  #else
  tolua_cclass(tolua_S,"VCC2DLoad","VCC2DLoad","CCActionInstant",NULL);
  #endif
  tolua_beginmodule(tolua_S,"VCC2DLoad");
   tolua_function(tolua_S,"new",tolua_MyGame_VCC2DLoad_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_VCC2DLoad_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_VCC2DLoad_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_VCC2DLoad_delete00);
   tolua_function(tolua_S,"startWithTarget",tolua_MyGame_VCC2DLoad_startWithTarget00);
   tolua_function(tolua_S,"reverse",tolua_MyGame_VCC2DLoad_reverse00);
   tolua_function(tolua_S,"copyWithZone",tolua_MyGame_VCC2DLoad_copyWithZone00);
   tolua_function(tolua_S,"initWithFile",tolua_MyGame_VCC2DLoad_initWithFile00);
   tolua_function(tolua_S,"actionWithFile",tolua_MyGame_VCC2DLoad_actionWithFile00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"SpriteExt","SpriteExt","CCSprite",tolua_collect_SpriteExt);
  #else
  tolua_cclass(tolua_S,"SpriteExt","SpriteExt","CCSprite",NULL);
  #endif
  tolua_beginmodule(tolua_S,"SpriteExt");
   tolua_function(tolua_S,"new",tolua_MyGame_SpriteExt_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_SpriteExt_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_SpriteExt_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_SpriteExt_delete00);
   tolua_function(tolua_S,"spriteWithFile",tolua_MyGame_SpriteExt_spriteWithFile00);
   tolua_function(tolua_S,"spriteWithFile",tolua_MyGame_SpriteExt_spriteWithFile01);
   tolua_function(tolua_S,"getFlag",tolua_MyGame_SpriteExt_getFlag00);
   tolua_function(tolua_S,"setFlag",tolua_MyGame_SpriteExt_setFlag00);
   tolua_function(tolua_S,"setDispearAction",tolua_MyGame_SpriteExt_setDispearAction00);
   tolua_function(tolua_S,"setCcatFile",tolua_MyGame_SpriteExt_setCcatFile00);
   tolua_function(tolua_S,"dispear",tolua_MyGame_SpriteExt_dispear00);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static const unsigned char B[] = {
    10,102,117,110, 99,116,105,111,110, 32, 67, 67, 95, 68, 69,
     71, 82, 69, 69, 83, 95, 84, 79, 95, 82, 65, 68, 73, 65, 78,
     83, 40, 95, 95, 65, 78, 71, 76, 69, 95, 95, 41, 10,114,101,
    116,117,114,110, 32, 40, 40, 95, 95, 65, 78, 71, 76, 69, 95,
     95, 41, 32, 42, 32, 48, 46, 48, 49, 55, 52, 53, 51, 50, 57,
     50, 53, 50, 41, 10,101,110,100, 10,102,117,110, 99,116,105,
    111,110, 32, 67, 67, 95, 82, 65, 68, 73, 65, 78, 83, 95, 84,
     79, 95, 68, 69, 71, 82, 69, 69, 83, 40, 95, 95, 65, 78, 71,
     76, 69, 95, 95, 41, 10,114,101,116,117,114,110, 32, 40, 40,
     95, 95, 65, 78, 71, 76, 69, 95, 95, 41, 32, 42, 32, 53, 55,
     46, 50, 57, 53, 55, 55, 57, 53, 49, 41, 10,101,110,100, 10,
     80, 84, 77, 95, 82, 65, 84, 73, 79, 32, 61, 32, 51, 48, 46,
     48, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 1");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  tolua_cclass(tolua_S,"Misc","Misc","",NULL);
  tolua_beginmodule(tolua_S,"Misc");
   tolua_function(tolua_S,"getChildByName",tolua_MyGame_Misc_getChildByName00);
   tolua_function(tolua_S,"getNodeName",tolua_MyGame_Misc_getNodeName00);
   tolua_function(tolua_S,"setNodeName",tolua_MyGame_Misc_setNodeName00);
   tolua_function(tolua_S,"getUserData",tolua_MyGame_Misc_getUserData00);
   tolua_function(tolua_S,"log",tolua_MyGame_Misc_log00);
   tolua_function(tolua_S,"fullPathFile",tolua_MyGame_Misc_fullPathFile00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"CNetManager","CNetManager","",NULL);
  tolua_beginmodule(tolua_S,"CNetManager");
   tolua_function(tolua_S,"getInstancePtr",tolua_MyGame_CNetManager_getInstancePtr00);
   tolua_function(tolua_S,"checkLogin",tolua_MyGame_CNetManager_checkLogin00);
   tolua_function(tolua_S,"loginServer",tolua_MyGame_CNetManager_loginServer00);
   tolua_function(tolua_S,"logoutServer",tolua_MyGame_CNetManager_logoutServer00);
   tolua_function(tolua_S,"getConnectionState",tolua_MyGame_CNetManager_getConnectionState00);
   tolua_function(tolua_S,"sendMsg",tolua_MyGame_CNetManager_sendMsg00);
   tolua_function(tolua_S,"sendChannelMsg",tolua_MyGame_CNetManager_sendChannelMsg00);
   tolua_function(tolua_S,"joinChannel",tolua_MyGame_CNetManager_joinChannel00);
   tolua_function(tolua_S,"leaveChannel",tolua_MyGame_CNetManager_leaveChannel00);
   tolua_function(tolua_S,"tick",tolua_MyGame_CNetManager_tick00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"CPlayerMsgProcess","CPlayerMsgProcess","",NULL);
  tolua_beginmodule(tolua_S,"CPlayerMsgProcess");
   tolua_function(tolua_S,"getInstancePtr",tolua_MyGame_CPlayerMsgProcess_getInstancePtr00);
   tolua_function(tolua_S,"setReceiveFunc",tolua_MyGame_CPlayerMsgProcess_setReceiveFunc00);
   tolua_function(tolua_S,"setSendFunc",tolua_MyGame_CPlayerMsgProcess_setSendFunc00);
   tolua_function(tolua_S,"processMsg",tolua_MyGame_CPlayerMsgProcess_processMsg00);
   tolua_function(tolua_S,"sendMsg",tolua_MyGame_CPlayerMsgProcess_sendMsg00);
   tolua_function(tolua_S,"writeInt8",tolua_MyGame_CPlayerMsgProcess_writeInt800);
   tolua_function(tolua_S,"writeInt32",tolua_MyGame_CPlayerMsgProcess_writeInt3200);
   tolua_function(tolua_S,"writeInt16",tolua_MyGame_CPlayerMsgProcess_writeInt1600);
   tolua_function(tolua_S,"writeUint32",tolua_MyGame_CPlayerMsgProcess_writeUint3200);
   tolua_function(tolua_S,"writeUint16",tolua_MyGame_CPlayerMsgProcess_writeUint1600);
   tolua_function(tolua_S,"writeFloat",tolua_MyGame_CPlayerMsgProcess_writeFloat00);
   tolua_function(tolua_S,"writeDouble",tolua_MyGame_CPlayerMsgProcess_writeDouble00);
   tolua_function(tolua_S,"readInt8",tolua_MyGame_CPlayerMsgProcess_readInt800);
   tolua_function(tolua_S,"readInt32",tolua_MyGame_CPlayerMsgProcess_readInt3200);
   tolua_function(tolua_S,"readInt16",tolua_MyGame_CPlayerMsgProcess_readInt1600);
   tolua_function(tolua_S,"readUint32",tolua_MyGame_CPlayerMsgProcess_readUint3200);
   tolua_function(tolua_S,"readUint16",tolua_MyGame_CPlayerMsgProcess_readUint1600);
   tolua_function(tolua_S,"readFloat",tolua_MyGame_CPlayerMsgProcess_readFloat00);
   tolua_function(tolua_S,"readDouble",tolua_MyGame_CPlayerMsgProcess_readDouble00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"UIWidget","UIWidget","CCLayer",tolua_collect_UIWidget);
  #else
  tolua_cclass(tolua_S,"UIWidget","UIWidget","CCLayer",NULL);
  #endif
  tolua_beginmodule(tolua_S,"UIWidget");
   tolua_function(tolua_S,"new",tolua_MyGame_UIWidget_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_UIWidget_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_UIWidget_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_UIWidget_delete00);
   tolua_function(tolua_S,"init",tolua_MyGame_UIWidget_init00);
   tolua_function(tolua_S,"create",tolua_MyGame_UIWidget_create00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"UIButton","UIButton","UIWidget",tolua_collect_UIButton);
  #else
  tolua_cclass(tolua_S,"UIButton","UIButton","UIWidget",NULL);
  #endif
  tolua_beginmodule(tolua_S,"UIButton");
   tolua_function(tolua_S,"new",tolua_MyGame_UIButton_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_UIButton_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_UIButton_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_UIButton_delete00);
   tolua_function(tolua_S,"create",tolua_MyGame_UIButton_create00);
   tolua_function(tolua_S,"initWithNormalImage",tolua_MyGame_UIButton_initWithNormalImage00);
   tolua_function(tolua_S,"registerScriptActiveHandler",tolua_MyGame_UIButton_registerScriptActiveHandler00);
   tolua_function(tolua_S,"unregisterScriptActiveHandler",tolua_MyGame_UIButton_unregisterScriptActiveHandler00);
   tolua_function(tolua_S,"activate",tolua_MyGame_UIButton_activate00);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_MyGame (lua_State* tolua_S) {
 return tolua_MyGame_open(tolua_S);
};
#endif

